"""
组织数据处理器
提供组织领域数据的处理和转换功能

警告: 此模块已废弃
新的实现请参考: app/services/organization/organization_service.py
将在后续版本中移除此模块
"""

import warnings
from typing import Dict, List, Any
from dataclasses import dataclass


def deprecated(message):
    """废弃装饰器"""
    def decorator(cls):
        warnings.warn(f"{cls.__name__} is deprecated. {message}", DeprecationWarning, stacklevel=2)
        return cls
    return decorator


@dataclass
class TagValue:
    """标签值数据结构 (已废弃)"""
    name: str
    value: Any


@deprecated("使用 organization_service.py 中的新实现替代")
class OrganizationDataProcessor:
    """
    组织数据处理器 (已废弃)
    
    提供各种组织数据的处理和转换方法，包括：
    - 标签值处理
    - 分布数据处理
    - 职级数据处理
    """

    @staticmethod
    def process_tag_value(tag_value: List[List[Dict]]) -> Dict[str, Any]:
        """
        处理标签值，提取名称和数量
        
        Args:
            tag_value: 原始标签值数据
            
        Returns:
            处理后的标签值字典
        """
        result = {}
        for item in tag_value:
            if len(item) >= 2:
                key = item[0].get('value', '').replace('(万)', '').replace('(亿)', '').replace('(户)', '')
                value = item[1].get('value', 0)
                try:
                    # 尝试转换为数值类型
                    if isinstance(value, str):
                        if '.' in value:
                            value = float(value)
                        else:
                            value = int(value)
                except (ValueError, TypeError):
                    pass
                result[key] = value
        return result

    @staticmethod
    def process_distribution_data(tag_value: List[List[Dict]]) -> Dict[str, Any]:
        """
        处理分布数据
        
        Args:
            tag_value: 原始分布数据
            
        Returns:
            处理后的分布数据字典，包含当前值、上一期值和变化值
        """
        result = {}
        total_current = 0
        total_previous = 0
        
        # 首先收集所有值并计算总和
        for item in tag_value:
            if len(item) >= 2:
                key = item[0].get('value', '')
                try:
                    current_value = float(item[1].get('value', 0))
                    # 这里模拟上一期数据，实际应该从历史数据中获取
                    previous_value = current_value * 0.9  # 假设上一期是当前值的90%
                    
                    result[key] = {
                        'current': current_value,
                        'previous': previous_value,
                        'change': current_value - previous_value
                    }
                    
                    total_current += current_value
                    total_previous += previous_value
                except (ValueError, TypeError):
                    continue
        
        # 添加总计
        if total_current > 0 or total_previous > 0:
            result['total'] = {
                'current': total_current,
                'previous': total_previous,
                'change': total_current - total_previous
            }
            
        return result

    @staticmethod
    def process_position_levels(tag_value: List[List[Dict]]) -> Dict[str, Dict[str, int]]:
        """
        处理职级数据
        
        Args:
            tag_value: 原始职级数据
            
        Returns:
            处理后的职级数据字典，按序列分类
        """
        p_levels = {}
        m_levels = {}
        b_levels = {}

        for item in tag_value:
            level = item[0]['value']
            count = int(item[1]['value'])

            if 'P' in level:
                p_levels[level] = count
            elif 'M' in level:
                m_levels[level] = count
            elif 'B' in level:
                b_levels[level] = count

        return {
            "P序列": p_levels,
            "M序列": m_levels,
            "B序列": b_levels
        }

    @staticmethod
    def normalize_value(value: str) -> Any:
        """
        标准化值的格式
        
        Args:
            value: 原始值字符串
            
        Returns:
            标准化后的值
        """
        # 移除单位
        value = value.replace('(万)', '').replace('(亿)', '').replace('(户)', '')
        
        # 尝试转换为数值
        try:
            if '.' in value:
                return float(value)
            return int(value)
        except ValueError:
            return value 